"use strict";

const Service = require("egg").Service;

class CategoryService extends Service {
  /**
   * 获取分类列表
   * @param {Object} query 查询条件
   * @param {Number} page 页码
   * @param {Number} pageSize 每页数量
   * @returns {Promise<Array>} 分类列表
   */
  async getList({ name, parent_id, page = 1, pageSize = 10 }) {
    const { Op } = this.app.Sequelize;
    const where = {};

    if (name) {
      where.name = { [Op.like]: `%${name}%` };
    }

    if (parent_id !== undefined) {
      where.parent_id = parent_id;
    }

    // if (query.is_show !== undefined) {
    //   where.is_show = query.is_show;
    // }

    const result = await this.ctx.model.Category.findAndCountAll({
      where,
      offset: (page - 1) * pageSize,
      limit: pageSize,
      order: [
        ["sort_order", "ASC"],
        ["id", "DESC"],
      ],
    });

    return {
      list: result.rows,
      total: result.count,
      page,
      pageSize,
    };
  }

  /**
   * 获取分类树
   * @returns {Promise<Array>} 分类树
   */
  async getTree() {
    const categories = await this.ctx.model.Category.findAll({
      order: [
        ["sort_order", "ASC"],
        ["id", "ASC"],
      ],
    });

    // 构建分类树
    const categoryMap = {};
    categories.forEach((category) => {
      categoryMap[category.id] = { ...category.toJSON(), children: [] };
    });

    const tree = [];
    categories.forEach((category) => {
      if (category.parent_id === 0) {
        tree.push(categoryMap[category.id]);
      } else {
        if (categoryMap[category.parent_id]) {
          categoryMap[category.parent_id].children.push(
            categoryMap[category.id]
          );
        }
      }
    });

    return tree;
  }

  /**
   * 根据ID获取分类
   * @param {Number} id 分类ID
   * @returns {Promise<Object>} 分类信息
   */
  async getById(id) {
    return this.ctx.model.Category.findByPk(id);
  }

  /**
   * 创建分类
   * @param {Object} data 分类数据
   * @returns {Promise<Object>} 创建结果
   */
  async create(data) {
    // 计算分类层级
    if (data.parent_id > 0) {
      const parent = await this.getById(data.parent_id);
      if (parent) {
        data.level = parent.level + 1;
      }
    } else {
      data.parent_id = 0;
      data.level = 1;
    }

    return this.ctx.model.Category.create(data);
  }

  /**
   * 更新分类
   * @param {Number} id 分类ID
   * @param {Object} data 分类数据
   * @returns {Promise<Number>} 更新结果
   */
  async update(id, data) {
    // 如果修改了父分类，需要重新计算层级
    if (data.parent_id !== undefined) {
      if (data.parent_id > 0) {
        const parent = await this.getById(data.parent_id);
        if (parent) {
          data.level = parent.level + 1;
        }
      } else {
        data.parent_id = 0;
        data.level = 1;
      }
    }

    return this.ctx.model.Category.update(data, {
      where: { id },
    });
  }

  /**
   * 删除分类
   * @param {Number} id 分类ID
   * @returns {Promise<Number>} 删除结果
   */
  async delete(id) {
    // 检查是否有子分类
    const hasChildren = await this.ctx.model.Category.count({
      where: { parent_id: id },
    });

    if (hasChildren > 0) {
      throw new Error("该分类下有子分类，不能删除");
    }

    // 检查是否有关联商品
    const hasProducts = await this.ctx.model.Product.count({
      where: { category_id: id },
    });

    if (hasProducts > 0) {
      throw new Error("该分类下有商品，不能删除");
    }

    return this.ctx.model.Category.destroy({
      where: { id },
    });
  }
}

module.exports = CategoryService;
